/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package duplicateur;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.activation.*;
import javax.swing.JFileChooser;
import javax.swing.JProgressBar;
import javax.swing.JTextField;
import javax.swing.filechooser.FileSystemView;

/**
 *
 * @author Aurélie
 */
public class Duplicateur {
    private ThreadControleCopy threadControleCopy;
    /**
     * Affiche la popup de choix des fichiers source
     *
     * @return tableau de fichiers sélectionnés
     */
    public File[] selectFile() {
        JFileChooser fileChooser;
        int returnValue;

        //Création du fileChooser
        fileChooser = new JFileChooser();
        //Activation du mode multi sélection
        fileChooser.setMultiSelectionEnabled(true);
        //Activation du mode de sélection des fichiers et des répertoires
        fileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
        //Récupération de la valeur de retour
        returnValue = fileChooser.showOpenDialog(fileChooser);
        //Vérifie si le choix est validé
        if (returnValue == JFileChooser.APPROVE_OPTION) {
            return fileChooser.getSelectedFiles();
        }
        return null;
    }

    /**
     * Récupère la liste des supports disponibles
     */
    public static ArrayList getAllSupport() {
        FileSystemView fileSystemView;

        ArrayList supports = new ArrayList<String>();

        fileSystemView = FileSystemView.getFileSystemView();
        for (File f : File.listRoots()) {
            if (fileSystemView.getSystemTypeDescription(f).equals("Disque amovible")) {
                supports.add(fileSystemView.getSystemDisplayName(f));
            }
        }
        return supports;
    }
    
    /**
     * Récupère la liste des disques amovibles
     */
    public ArrayList getAllDisquesAmovibles() {
        FileSystemView fileSystemView;

        ArrayList supports = new ArrayList<String>();

        fileSystemView = FileSystemView.getFileSystemView();
        for (File f : File.listRoots()) {
            if (!fileSystemView.getSystemTypeDescription(f).equals("Disque amovible")) {
                System.out.println(fileSystemView.getSystemDisplayName(f));
                supports.add(f.toString().substring(0, 2));
            }
        }
        return supports;
    }

    /**
     * Création des dossiers dans les supports sélectionné s'il n'existe pas
     */
    public void ejectUsb() {
        ArrayList tamere = new ArrayList<String>();
        tamere = getAllSupport();
        for (Object f : tamere) {
            String file = (String) f;
            char lettre = file.charAt(file.length() - 3);
            System.out.println("Lettre " + lettre);
            String[] command
                    = {
                        "cmd",};
            Process p = null;
            try {
                p = Runtime.getRuntime().exec("usb_disk_eject /removeletter " + lettre);
            } catch (IOException ex) {
                Logger.getLogger(Duplicateur.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public static void createDossier(String nom, File[] supports) {

        //Parcours les supports sélectionnés
        for (int i = 0; supports[i] != null; i++) {

            //Créer le dossier 
            File dossier = new File(supports[i].getAbsolutePath() + "/" + nom);

            //Vérifie si le dossier existe déjà
            if (!dossier.exists()) {
                //Créé le dossier sur le support
                dossier.mkdir();
            }
        }
    }

    public File[] supportsStringToFile(String[] supports) {
        FileSystemView fileSystemView;
        File[] supportsFile = new File[supports.length];
        int i = 0;

        //Parcours les supports sélectionnés
        for (String support : supports) {
            //Récupère la liste des supports du système
            fileSystemView = FileSystemView.getFileSystemView();
            //Parcours les supports du système
            for (File disque : File.listRoots()) {
                //Vérifie si le support est sélectionné
                if (fileSystemView.getSystemDisplayName(disque).equals(support)) {
                    supportsFile[i] = disque;
                    i++;
                }
            }
        }

        return supportsFile;
    }


    /**
     * Copie les fichiers destination dans le dossier sur tout les supports sélectionnés
     * @param selectedFile 
     * @param supports
     * @param dossierNom
     * @param interfaceD
     * @param tabProgressBar
     * @return 
     */
    public void copySupports(File[] selectedFile, File[] supports, File dossierChemin, InterfaceDuplicateur interfaceD, JProgressBar[] tabProgressBar) {
        File dossier;
        ThreadCopy[] tabThread = new ThreadCopy[11];
        ThreadCopy threadCopy;
        long tailleFiles = 0;
        boolean enoughSpace = true;
        String dossierNom = null;

        //Parcours des fichiers à copier
        for(File f : selectedFile) {
            tailleFiles += f.length();
        }
        
        for(int i = 0; supports[i] != null && enoughSpace == true ; i++) {
            dossier = new File(supports[i].getAbsolutePath());
            
            if (dossier.getUsableSpace() < tailleFiles) {
                enoughSpace = false;
            }
        }
        
        if (dossierChemin != null) {
            dossierNom = dossierChemin.getPath().substring(dossierChemin.getPath().indexOf("\\"));
            
        }
        //Vérification de l'espace disponible
        if (enoughSpace == true) {
            //Parcours des supports
            for(int i = 0; supports[i] != null; i++) {
                //Vérification du nom du dossier
                if (dossierNom == null) {
                    //Récupération de la racine
                    dossier = new File(supports[i].getAbsolutePath());
                } else {
                    //Récupération du dossier
                    dossier = new File(supports[i].getAbsolutePath()+"/"+dossierNom);
                    
                    if(!dossier.exists()) {
                        dossier.mkdirs();
                    }
                }


                interfaceD.getJTextAreaEtat().setText(interfaceD.getJTextAreaEtat().getText()+"\n Copie en cour sur "+supports[i].getAbsolutePath()+" ...");
                threadCopy = new ThreadCopy(selectedFile, dossier, tabProgressBar[i], interfaceD);
                tabThread[i] = threadCopy;
                threadCopy.start();
            }

            this.threadControleCopy = new ThreadControleCopy(tabThread, interfaceD);
            this.threadControleCopy.start();
        } else {
            interfaceD.getJTextAreaEtat().setText(interfaceD.getJTextAreaEtat().getText()+"\n Un des supports ne possède pas assez d'espace disque");
        }
    }

    
    public void abandonner() {
        this.threadControleCopy.stopThreads();
    }
    private static class SyncPipe implements Runnable {

        public SyncPipe(InputStream istrm, OutputStream ostrm) {
            istrm_ = istrm;
            ostrm_ = ostrm;
        }

        public void run() {
            try {
                final byte[] buffer = new byte[1024];
                for (int length = 0; (length = istrm_.read(buffer)) != -1;) {
                    ostrm_.write(buffer, 0, length);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        private final OutputStream ostrm_;
        private final InputStream istrm_;
    }
}
